
/**
 * 
 * 【比赛】选手前3名的编号
 * 
 * 题目描述

一个有 N 个选手参加比赛，选手编号为1 ~ N（3 ≤ N ≤ 100），有 M（3 ≤ M ≤ 10）个评委对选手进行打分。

打分规则为每个评委对选手打分，最高分10分，最低分1分。
请计算得分最多的3位选手的编号。

如果得分相同，则得分高分值最多的选手排名靠前（10分数量相同，则比较9分的数量，以此类推，用例中不会出现多个选手得分完全相同的情况）。
输入描述
第一行为半角逗号分割的两个正整数，第一个数字表示 M（3 ≤ M ≤ 10）个评委，第二个数字表示 N（3 ≤ N ≤ 100）个选手。

第 2 到 M+1 行是半角逗号分割的整数序列，表示评委为每个选手的打分，0号下标数字表示1号选手分数，1号下标数字表示2号选手分数，依次类推。

输出描述
选手前3名的编号。

注：若输入为异常，输出-1，如 M、N、打分不在范围内。
用例
输入	4,5
10,6,9,7,6
9,10,6,7,5
8,10,6,5,10
9,10,8,4,9
输出	2,1,5
说明	
第一行代表有4个评委，5个选手参加比赛
矩阵代表是4*5，每个数字是选手的编号，每一行代表一个评委对选手的打分排序，
2号选手得分36分排第1，1号选手36分排第2，5号选手30分(2号10分值有3个，1号10分值只有1个，所以2号排第一)
输入	2,5
7,3,5,4,2
8,5,4,4,3
输出	-1
说明	只有2个评委，要求最少为3个评委
输入	4,2
8,5
5,6
10,4
8,9
输出	-1
说明	只有2名选手参加，要求最少为3名
输入	4,5
11,6,9,7,8
9,10,6,7,8
8,10,6,9,7
9,10,8,6,7
输出	-1
说明	第一个评委给第一个选手打分11，无效分数

 */

import java.util.ArrayList;
import java.util.Scanner;
import java.util.StringJoiner;

/**
  * 
  题目解析
本题考察自定义排序。

我们需要统计编号 1 ~ N 的每个选手：

总分
各个具体得分（1分~10分）的数量
优先按照总分降序，若总分相同，则按照高分的数量降序（比如10分数量相同，则继续比较9分数量，9分数量相同，则继续比较8分数量）。

总分的统计很简单，我们可以定义一个长度为 n+1 的数组 sumScore，数组索引 1~n 对应编号 1~n，数组元素是对应（索引）编号选手的总分。

比如 sumSocre[i] 表示编号为 i 的庪的总分。
由于本题评委的打分范围只能是 1 ~ 10分，因此我们可以定义一个二维数组 countScore，该二维数组有 n + 1 行，10 + 1 列。

比如 countSocre[i][j] 表示 编号为 i 的选手，得分 j 的数量。

  */
public class 选手前3名的编号 {
   
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in).useDelimiter("[,\n]");
 
        int m = sc.nextInt();
 
        // m 范围校验
        if (m < 3 || m > 10) {
            System.out.println(-1);
            return;
        }
 
        int n = sc.nextInt();
 
        // n 范围校验
        if (n < 3 || n > 100) {
            System.out.println(-1);
            return;
        }
 
        // countScore[i] 表示编号为 i 的选手的得分情况
        // countScore[i] 也是一个数组，长度为11, 数组索引 1 ~ 10 对应得分 1 ~ 10, 数组元素表示数组索引得分的数量
        int[][] countScore = new int[n + 1][11];
 
        // sumScore[i] 表示编号 i 的选手的总分
        int[] sumScore = new int[n + 1];
 
        for (int i = 0; i < m; i++) {
            for (int j = 1; j <= n; j++) {
                int score = sc.nextInt();
 
                // 得分 范围校验
                if (score < 1 || score > 10) {
                    System.out.println(-1);
                    return;
                }
 
                // 编号 j 的选手, 得分score的数量+1
                countScore[j][score]++;
                // 编号 j 的选手, 总分+score
                sumScore[j] += score;
            }
        }
 
        // 1~n的选手编号集合
        ArrayList<Integer> nums = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            nums.add(i);
        }
 
        // 记录结果
        StringJoiner sj = new StringJoiner(",");
 
        // 编号排序
        nums.stream().sorted((i, j) -> {
            // 总分越高, 则排名越靠前
            if (sumScore[i] != sumScore[j]) {
                return sumScore[j] - sumScore[i];
            }
 
            // 总分相同，则高分数量越多，则排名越靠前
            // 从10分数量开始比较
            for (int score = 10; score >= 1; score--) {
                if (countScore[i][score] != countScore[j][score]) {
                    return countScore[j][score] - countScore[i][score];
                }
            }
 
            return 0;
        }).limit(3).forEach(num -> sj.add(num + "")); // 只选取前3名
 
        System.out.println(sj);

    }
}
